// index.js
const api = require('../../utils/api');
const { IMG_URL } = require('../../utils/request');
const defaultAvatarUrl = '/assets/images/wxlogo.png';

Page({
  data: {
    userInfo: {
      avatarUrl: defaultAvatarUrl,
      nickName: '',
    },
    hasUserInfo: false,
    canIUseGetUserProfile: wx.canIUse('getUserProfile'),
    canIUseNicknameComp: wx.canIUse('input.type.nickname'),
    filePath: '',
    // 添加热门课程列表数据
    courses: [
      {
        id: 1,
        title: '微积分基础',
        desc: '适合大一新生的微积分入门课程',
        image: '/assets/images/course1.png',
        rating: '4.9',
        students: 328
      },
      {
        id: 2,
        title: '线性代数',
        desc: '工科必修的线性代数精讲',
        image: '/assets/images/course2.png',
        rating: '4.8',
        students: 256
      }
    ],
    // 添加最近学习记录
    recentStudy: [
      {
        id: 1,
        title: '高等数学笔记',
        time: '2天前',
        progress: '75%',
        icon: 'icon-file'
      },
      {
        id: 2,
        title: 'Java编程基础',
        time: '昨天',
        progress: '32%',
        icon: 'icon-code'
      }
    ],
    // 我的文档列表
    documents: [],
    activeTabIndex: 0,

    // 控制操作菜单的显示
    showActionSheet: false,
    currentDocId: null,
    currentDocTitle: '',
    // 控制重命名弹窗
    showRenameModal: false,
    // 添加分享相关数据
    shareDocId: null,
    shareDocTitle: '',
    
    // 示例文件数据
    sampleDocument: null,
    
    // 上传状态标志
    isUploading: false,
  },
  
  // 复制文档
  copyDocument() {
    wx.showActionSheet({
      itemList: ['选择要复制的文档', '从其他应用导入文件', '创建副本'],
      success: (res) => {
        switch(res.tapIndex) {
          case 0:
            // 选择要复制的文档
            wx.showToast({
              title: '请选择要复制的文档',
              icon: 'none',
              duration: 1500
            });
            break;
          case 1:
            // 从其他应用导入
            wx.chooseMessageFile({
              count: 1,
              type: 'file',
              extension: ['pdf', 'doc', 'docx', 'ppt', 'pptx'],
              success: (fileRes) => {
                wx.showToast({
                  title: '文件导入成功',
                  icon: 'success'
                });
              }
            });
            break;
          case 2:
            // 创建副本
            wx.showToast({
              title: '创建文档副本',
              icon: 'none',
              duration: 1500
            });
            break;
        }
      }
    });
  },
  
  bindViewTap() {
    const user = {
      name: this.data.userInfo.nickName,
      avatar: this.data.userInfo.avatarUrl,
      rank: 1, 
      score: 1850,
      isFollowed: false,
    };
    wx.navigateTo({
      url: `../userProfile/userProfile?user=${encodeURIComponent(JSON.stringify(user))}`
    });
  },
  // 跳转到排行榜页面
  goToRanking() {
    wx.navigateTo({
      url: '../ranking/ranking'
    })
  },
  // 跳转到PDF查看器
  goToViewer() {
    // 设置默认的PDF图片列表
    const imageUrls = [
      '/assets/images/image-1.png',
      '/assets/images/image-2.png'
    ];
    
    // 将图片列表序列化并通过URL参数传递
    const imageUrlsStr = JSON.stringify(imageUrls);
    wx.navigateTo({
      url: `../pdf-viewer/pdf-viewer?imageUrls=${encodeURIComponent(imageUrlsStr)}&pdfId=sample_pdf`,
    });
  },
  // 跳转到示例文件查看器
  goToSampleViewer(e) {
    const docId = e.currentTarget.dataset.id;
    const sampleDoc = this.data.sampleDocument;
    
    if (sampleDoc) {
      console.log('[首页] 打开示例文件:', sampleDoc.title, '文档ID:', docId, '签名标志:', sampleDoc.signFlag);
      
      // 根据signFlag判断是否需要弹出选择框
      if (sampleDoc.signFlag == 1) {
        // 已签名，弹出选择框
        wx.showActionSheet({
          itemList: ['预览文档', '重新签名'],
          success: (res) => {
            if (res.tapIndex === 0) {
              // 用户选择"预览文档"
              console.log('[示例文件] 用户选择预览文档');
              this.loadSampleDocument(docId, 'preview');
            } else if (res.tapIndex === 1) {
              // 用户选择"重新签名"
              console.log('[示例文件] 用户选择重新签名');
              this.loadSampleDocument(docId, 'resign');
            }
          },
          fail: (res) => {
            console.log('[示例文件] 用户取消选择', res.errMsg);
          }
        });
      } else {
        // 未签名，直接打开文档进行签名
        console.log('[示例文件] 未签名，直接进行签名');
        this.loadSampleDocument(docId, 'sign');
      }
    } else {
      wx.showToast({
        title: '示例文件加载中，请稍后再试',
        icon: 'none'
      });
    }
  },
  // 显示示例文件操作菜单
  showSampleActions(e) {
    // 阻止事件冒泡
    e.stopPropagation();
    
    const docId = e.currentTarget.dataset.id;
    const title = e.currentTarget.dataset.title;
    
    console.log('[示例文件] 显示操作菜单，文档ID:', docId, '标题:', title);
    
    // 显示操作菜单
    wx.showActionSheet({
      itemList: ['预览文档', '重新签名'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 预览文档
          console.log('[示例文件] 操作菜单 - 用户选择预览文档');
          this.loadSampleDocument(docId, 'preview');
        } else if (res.tapIndex === 1) {
          // 重新签名
          console.log('[示例文件] 操作菜单 - 用户选择重新签名');
          this.loadSampleDocument(docId, 'resign');
        }
      },
      fail: (res) => {
        console.log('[示例文件] 操作菜单 - 用户取消选择', res.errMsg);
      }
    });
  },
  // 查看课程详情
  viewCourse(e) {
    const courseId = e.currentTarget.dataset.id;
    wx.showToast({
      title: '功能开发中',
      icon: 'none'
    });
  },
  // 查看最近学习详情
  viewRecentStudy(e) {
    const studyId = e.currentTarget.dataset.id;
    wx.showToast({
      title: '功能开发中',
      icon: 'none'
    });
  },
  // 查看全部最近学习
  viewAllRecent() {
    wx.showToast({
      title: '功能开发中',
      icon: 'none'
    });
  },
  // 查看全部课程
  viewAllCourses() {
    wx.showToast({
      title: '功能开发中',
      icon: 'none'
    });
  },
  onChooseAvatar(e) {
    const { avatarUrl } = e.detail
    const { nickName } = this.data.userInfo
    this.setData({
      "userInfo.avatarUrl": avatarUrl,
      hasUserInfo: nickName && avatarUrl && avatarUrl !== defaultAvatarUrl,
    })
  },
  onInputChange(e) {
    const nickName = e.detail.value
    const { avatarUrl } = this.data.userInfo
    this.setData({
      "userInfo.nickName": nickName,
      hasUserInfo: nickName && avatarUrl && avatarUrl !== defaultAvatarUrl,
    })
  },
  getUserProfile(e) {
    // 推荐使用wx.getUserProfile获取用户信息，开发者每次通过该接口获取用户个人信息均需用户确认，开发者妥善保管用户快速填写的头像昵称，避免重复弹窗
    wx.getUserProfile({
      desc: '展示用户信息', // 声明获取用户个人信息后的用途，后续会展示在弹窗中，请谨慎填写
      success: (res) => {
        console.log(res)
        this.setData({
          userInfo: res.userInfo,
          hasUserInfo: true
        })
      }
    })
  },
  importFile: function() {
    wx.chooseMessageFile({
      count: 1,
      type: 'file',
      extension: ['pdf'],
      success: (res) => {
        const tempFilePath = res.tempFiles[0].path;
        // 跳转到签名页面，并传递文件路径
        wx.navigateTo({
          url: `../pdfSign/pdfSign?filePath=${tempFilePath}`
        });
      },
      fail: (err) => {
        console.error('选择文件失败', err);
        if (err.errMsg.indexOf('cancel') === -1) {
          wx.showToast({
            title: '选择文件失败',
            icon: 'none'
          });
        }
      }
    });
  },
  goToPdfViewer() {
    // 使用示例pdfId
    const samplePdfId = 'sample_pdf';
    
    wx.navigateTo({
      url: `../pdf-viewer/pdf-viewer?pdfId=${samplePdfId}`,
    });
  },
  goToExternalPage() {
    wx.navigateTo({
      url: '../external-viewer/external-viewer',
    });
  },
  // 打开文档
  openDocument(event) {
    const docId = event.currentTarget.dataset.id;
    const signFlag = event.currentTarget.dataset.signflag;
    console.log('打开文档，ID:', docId, '签名标志:', signFlag);
    
    // 如果已经签过名，弹出选择框
    if (signFlag == 1) {
      wx.showActionSheet({
        itemList: ['预览文档', '重新签名'],
        success: (res) => {
          if (res.tapIndex === 0) {
            // 用户选择"预览文档"
            console.log('用户选择预览文档');
            this.loadDocument(docId, 'preview');
          } else if (res.tapIndex === 1) {
            // 用户选择"重新签名"
            console.log('用户选择重新签名');
            this.loadDocument(docId, 'resign');
          }
        },
        fail: (res) => {
          console.log('用户取消选择', res.errMsg);
        }
      });
    } else {
      // 直接打开文档（首次签名）
      this.loadDocument(docId, 'sign');
    }
  },
  
  // 加载文档内容
  loadDocument(docId, actionType = 'sign') {
    wx.showLoading({
      title: '加载中...',
    });
    
    // 检查登录状态
    const openId = wx.getStorageSync('openId');
    
    // 根据操作类型设置 signType
    let signType = 1; // 默认预览
    if (actionType === 'preview') {
      signType = 1; // 预览文档
    } else if (actionType === 'resign') {
      signType = 2; // 重新签名
    }
    
    // 构建URL参数
    let url = `../pdf-viewer/pdf-viewer?pdfId=${docId}&actionType=${actionType}&signType=${signType}`;
    
    // 如果已登录，必须传递 openId
    if (openId) {
      url += `&openId=${openId}`;
      console.log('[文档] 用户已登录，传递 openId:', openId, '操作类型:', actionType, 'signType:', signType);
    } else {
      console.log('[文档] 用户未登录，操作类型:', actionType, 'signType:', signType);
    }
    
    wx.navigateTo({ 
      url,
      success: () => {
        wx.hideLoading();
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('跳转到PDF查看器失败', err);
        wx.showToast({
          title: '打开文档失败',
          icon: 'none'
        });
      }
    });
  },
  // 查看所有文档
  viewAllDocuments() {
    wx.showToast({
      title: '查看全部文档',
      icon: 'none'
    });
  },
  // 显示更多操作
  showMoreActions(e) {
    const { id, title } = e.currentTarget.dataset;
    this.setData({
      showActionSheet: true,
      currentDocId: id,
      currentDocTitle: title
    });
  },
  // 隐藏操作菜单
  hideActionSheet() {
    this.setData({
      showActionSheet: false,
      currentDocId: null,
      currentDocTitle: ''
    });
  },
  // 删除文档
  deleteDocument() {
    const docId = this.data.currentDocId;
    this.hideActionSheet();

    // 检查登录状态
    const openId = wx.getStorageSync('openId');
    if (!openId) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '删除中...',
    });

    // 传递 openId 参数
    api.article.deleteArticle({ id: docId, openId: openId })
      .then(res => {
        wx.hideLoading();
        wx.showToast({
          title: '删除成功',
          icon: 'success'
        });
        // 刷新列表
        this.getArticleList();
      })
      .catch(err => {
        wx.hideLoading();
        // 错误提示已在api.js中统一处理
        console.error('删除失败', err);
      });
  },
  // 重命名文档
  renameDocument() {
    this.setData({
      showActionSheet: false, // 直接隐藏操作菜单
      showRenameModal: true   // 显示重命名弹窗
    });
  },
  // 取消重命名
  onRenameCancel() {
    this.setData({
      showRenameModal: false
    });
  },
  // 确认重命名
  onRenameConfirm(e) {
    const newTitle = e.detail.value;
    if (!newTitle) {
      wx.showToast({
        title: '名称不能为空',
        icon: 'none'
      });
      return;
    }

    // 检查登录状态
    const openId = wx.getStorageSync('openId');
    if (!openId) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    this.setData({
      showRenameModal: false
    });

    const docId = this.data.currentDocId;
    
    wx.showLoading({
      title: '保存中...',
    });

    // 传递 openId 参数
    api.article.updateArticle({ id: docId, fileName: newTitle, openId: openId })
      .then(res => {
        wx.hideLoading();
        wx.showToast({
          title: '重命名成功',
          icon: 'success'
        });
        // 刷新列表
        this.getArticleList();
      })
      .catch(err => {
        wx.hideLoading();
        console.error('重命名失败', err);
      });
  },
  // 添加新文档
  addDocument() {
    wx.showActionSheet({
      itemList: ['上传本地文件', '新建文档', '导入外部文档'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 上传本地文件
          wx.chooseMessageFile({
            count: 1,
            type: 'file',
            extension: ['pdf', 'doc', 'docx', 'ppt', 'pptx', 'xls', 'xlsx'],
            success: (res) => {
              const tempFilePath = res.tempFiles[0].path;
              wx.showToast({
                title: '文件上传成功',
                icon: 'success'
              });
            }
          });
        } else if (res.tapIndex === 1) {
          // 新建文档
          wx.showToast({
            title: '新建文档功能开发中',
            icon: 'none'
          });
        } else if (res.tapIndex === 2) {
          // 导入外部文档
          wx.showToast({
            title: '导入功能开发中',
            icon: 'none'
          });
        }
      }
    });
  },
  // 切换分类标签
  switchTab(e) {
    const index = e.currentTarget.dataset.index;
    this.setData({
      activeTabIndex: index
    });
  },
  onLoad(options) {
    // 页面加载时执行
    
    // 移除这里的调用，避免重复调用
    // this.callArticleModel();
    
    // 添加调试信息，确认初始数据状态
    console.log('[首页] onLoad - 初始sampleDocument:', this.data.sampleDocument);
    
    // 处理分享进入的情况
    if (options && options.sharedDocId) {
      const sharedDocId = options.sharedDocId;
      console.log('通过分享进入，文档ID:', sharedDocId);
      
      // 如果用户已登录，可以直接打开分享的文档
      const openId = wx.getStorageSync('openId');
      if (openId) {
        // 延迟一下，确保页面加载完成
        setTimeout(() => {
          this.openDocument({
            currentTarget: {
              dataset: {
                id: sharedDocId
              }
            }
          });
        }, 500);
      } else {
        // 未登录，先保存文档ID，登录后再打开
        wx.setStorageSync('pendingSharedDocId', sharedDocId);
        
        // 提示用户登录
        wx.showModal({
          title: '查看分享文档',
          content: '请先登录后查看分享的文档',
          confirmText: '去登录',
          success: (res) => {
            if (res.confirm) {
              const app = getApp();
              app.globalData.showLoginModal = true;
              wx.switchTab({
                url: '/pages/profile/profile'
              });
            }
          }
        });
      }
    }
  },
  onShow() {
    // 检查是否正在上传，如果正在上传则不显示loading以免干扰
    const isUploading = this.data.isUploading || false;
    console.log('[DEBUG] onShow被调用, isUploading:', isUploading);
    
    // 每次页面显示时都尝试获取最新列表，但上传时不显示loading
    console.log('[DEBUG] onShow调用getArticleList，showLoading参数:', !isUploading);
    this.getArticleList(!isUploading);
    
    // 刷新示例文件数据，上传时也不显示loading
    console.log('[DEBUG] onShow调用callArticleModel，isUploading:', isUploading);
    this.callArticleModel(!isUploading);
    
    // 检查是否有待处理的分享文档
    const pendingSharedDocId = wx.getStorageSync('pendingSharedDocId');
    const openId = wx.getStorageSync('openId');
    
    if (pendingSharedDocId && openId) {
      // 清除待处理标记
      wx.removeStorageSync('pendingSharedDocId');
      
      // 延迟一下，确保文档列表已加载
      setTimeout(() => {
        this.openDocument({
          currentTarget: {
            dataset: {
              id: pendingSharedDocId
            }
          }
        });
      }, 1000);
    }
  },
  onPdfItemClick(event) {
    const pdfId = event.currentTarget.dataset.id || 'sample_pdf';
    wx.navigateTo({
      url: `/pages/pdf-viewer/pdf-viewer?pdfId=${pdfId}`
    });
  },
  uploadFileHandler() {
    console.log('[首页] 开始处理上传点击事件');
    const openId = wx.getStorageSync('openId');
    console.log('[首页] 从缓存中读取到的openId:', openId ? `"${openId}"` : '未找到');

    if (openId) {
      console.log('[首页] 判断结果：已登录，准备选择签名模式');
      // 已登录，弹出签名模式选择
      wx.showActionSheet({
        itemList: ['单签(一人签一份)', '多签(多人签一份)'],
        success: (res) => {
          // 根据选择设置签名模式
          const signModel = res.tapIndex === 0 ? 1 : 2;
          console.log('[首页] 用户选择了签名模式:', signModel === 1 ? '单签' : '多签');
          
          // 选择文件上传 - 在选择文件之前就设置上传状态
          console.log('[DEBUG] 用户已选择签名模式，设置isUploading为true');
          this.setData({ isUploading: true });
          
          wx.chooseMessageFile({
            count: 1,
            type: 'file',
            extension: ['pdf', 'doc', 'docx'],
            success: (fileRes) => {
              const tempFile = fileRes.tempFiles[0];
              
              // 手动检查文件后缀名
              const allowedExtensions = ['pdf', 'doc', 'docx'];
              const fileName = tempFile.name || '';
              const fileExtension = fileName.split('.').pop().toLowerCase();
      
              if (allowedExtensions.indexOf(fileExtension) === -1) {
                wx.showToast({
                  title: '请选择.pdf, .doc或.docx格式的文件',
                  icon: 'none'
                });
                // 文件格式错误时重置状态
                this.setData({ isUploading: false });
                return;
              }
      
              console.log('选择的文件:', tempFile, '签名模式:', signModel);
              
              // 文件选择成功后立即显示loading
              console.log('[DEBUG] 开始显示loading - 正在上传文件..., 时间戳:', Date.now());
              wx.showLoading({
                title: '正在上传文件...',
                mask: true
              });
              console.log('[DEBUG] loading已显示, 时间戳:', Date.now());
              
              this.uploadFile(tempFile.path, tempFile.name, signModel);
            },
            fail: (err) => {
              console.log('取消选择文件', err);
              // 用户取消选择文件时重置状态
              console.log('[DEBUG] 用户取消选择文件，重置isUploading为false');
              this.setData({ isUploading: false });
            }
          });
        },
        fail: (err) => {
          console.log('取消选择签名模式', err);
        }
      });
    } else {
      // 未登录，先显示提示框
      console.log('[首页] 判断结果：未登录，显示登录提示');
      wx.showModal({
        title: '提示',
        content: '请先登录后再上传文件',
        confirmText: '去登录',
        success: (res) => {
          if (res.confirm) {
            console.log('[首页] 用户点击确定，跳转到"我的"页面并显示登录框');
            const app = getApp();
            app.globalData.showLoginModal = true;
            wx.switchTab({
              url: '/pages/profile/profile'
            });
          }
        }
      });
    }
  },
  
  // 上传文件到服务器
  uploadFile(filePath, fileName, signModel = 1) {
    const startTime = Date.now();
    console.log('[DEBUG] 进入uploadFile方法, 时间戳:', startTime);
    
    const openId = wx.getStorageSync('openId');
    
    console.log('[DEBUG] 准备调用api.file.upload接口, 时间戳:', Date.now());
    // 禁用request.js的自动loading管理，我们手动管理
    const uploadPromise = api.file.upload(filePath, fileName, openId, signModel, { showLoading: false });
    console.log('[DEBUG] 已发起上传请求，等待响应..., 时间戳:', Date.now());
    uploadPromise
      .then(res => {
        console.log('[DEBUG] 上传接口返回成功, 时间戳:', Date.now(), '耗时:', Date.now() - startTime + 'ms', res);
        
        // 不要关闭loading，直接更新提示文字
        console.log('[DEBUG] 更新loading状态为"刷新列表中...", 时间戳:', Date.now());
        wx.showLoading({
          title: '刷新列表中...',
          mask: true
        });
        console.log('[DEBUG] loading状态已更新, 时间戳:', Date.now());
        
        // 上传成功后刷新列表
        console.log('[DEBUG] 准备调用getArticleListPromise, 时间戳:', Date.now());
        return this.getArticleListPromise();
      })
      .then(() => {
        // 列表刷新完成后才关闭loading
        console.log('[DEBUG] 列表刷新完成，准备关闭loading, 时间戳:', Date.now(), '总耗时:', Date.now() - startTime + 'ms');
        wx.hideLoading();
        console.log('[DEBUG] loading已关闭, 时间戳:', Date.now());
        
        // 重置上传状态
        this.setData({ isUploading: false });
        console.log('[DEBUG] 设置isUploading为false（成功）');
        
        // 显示成功提示
        console.log('[DEBUG] 显示成功提示, 时间戳:', Date.now());
        wx.showToast({
          title: '上传成功',
          icon: 'success'
        });
      })
      .catch(err => {
        // 确保在任何错误情况下都关闭loading
        console.log('[DEBUG] 捕获到错误，准备关闭loading, 时间戳:', Date.now(), '耗时:', Date.now() - startTime + 'ms');
        wx.hideLoading();
        console.log('[DEBUG] 错误情况下loading已关闭, 时间戳:', Date.now());
        
        // 重置上传状态
        this.setData({ isUploading: false });
        console.log('[DEBUG] 设置isUploading为false（失败）');
        
        // 错误提示已在request.js中统一处理
        console.error('[DEBUG] 上传失败', err);
      });
  },
  // 调用articleModel接口
  callArticleModel(showLoading = true) {
    console.log('[DEBUG] 进入callArticleModel方法, showLoading:', showLoading);
    
    // 检查登录状态
    const openId = wx.getStorageSync('openId');
    
    // 根据登录状态决定传递的参数
    let params = {};
    if (openId) {
      // 如果已登录，传递 openId 参数
      params = { openId: openId };
      console.log('[首页] 用户已登录，传递 openId:', openId);
    } else {
      // 如果未登录，不传递 openId 参数
      console.log('[首页] 用户未登录，不传递 openId 参数');
    }
    
    console.log('[DEBUG] callArticleModel准备调用接口，showLoading:', showLoading);
    api.article.articleModel(params, { showLoading: showLoading })
      .then(res => {
        console.log('[首页] articleModel接口调用成功:', res);
        
        // 处理返回的数据 - 接口直接返回数据对象，不是包装在res.data中
        if (res && res.id) {
          const data = res; // 直接使用res，不是res.data
          console.log('[首页] 原始数据:', data);
          
          // 格式化文件类型
          const fileName = data.fileName || '未知文件';
          const fileExtension = fileName.split('.').pop().toLowerCase();
          let fileType = 'DOC';
          if (fileExtension === 'pdf') fileType = 'PDF';
          else if (fileExtension === 'docx' || fileExtension === 'doc') fileType = 'WORD';
          console.log('[首页] 文件类型:', fileType);
          
          // 格式化创建时间
          const createTime = data.createTime || '';
          const timeAgo = this.formatTimeAgo(createTime);
          console.log('[首页] 时间格式化:', createTime, '->', timeAgo);
          
          // 格式化签名模式
          const signModel = data.signModel || '1';
          const signModelText = signModel === '1' ? '单签' : '多签';
          const signModelClass = signModel === '1' ? 'single' : 'multiple';
          console.log('[首页] 签名模式:', signModel, '->', signModelText, signModelClass);
          
          // 处理头像URL
          const avatarUrl = data.avatarUrl 
            ? IMG_URL + data.avatarUrl 
            : '/assets/images/wxlogo.png'; // 默认头像
          console.log('[首页] 头像URL:', data.avatarUrl, '->', avatarUrl);
          
          // 存储示例文件数据
          const sampleDocument = {
            id: data.id,
            title: fileName,
            type: fileType,
            date: timeAgo,
            signModel: signModel,
            signModelText: signModelText,
            signModelClass: signModelClass,
            signCount: data.signCount || 0,
            signFlag: data.signFlag || 0, // 添加signFlag字段
            creatorNickName: data.nickName || '未知用户',
            creatorAvatarUrl: avatarUrl,
            createTime: data.createTime
          };
          
          console.log('[首页] 格式化后的示例文件数据:', sampleDocument);
          
          this.setData({
            sampleDocument: sampleDocument
          }, () => {
            // setData 回调函数，确认数据设置成功
            console.log('[首页] setData回调 - 数据已更新:', this.data.sampleDocument);
          });
          
          // 添加调试信息，确认数据是否正确设置
          console.log('[首页] setData完成，当前sampleDocument:', this.data.sampleDocument);
        } else {
          console.log('[首页] 接口返回数据格式不正确:', res);
        }
      })
      .catch(err => {
        console.error('[首页] articleModel接口调用失败:', err);
      });
  },
  
  // 格式化时间为相对时间
  formatTimeAgo(timeStr) {
    if (!timeStr) return '未知时间';
    
    try {
      const createTime = new Date(timeStr.replace(/-/g, '/'));
      const now = new Date();
      const diffTime = now - createTime;
      const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
      
      if (diffDays === 0) return '今天';
      if (diffDays === 1) return '昨天';
      if (diffDays < 7) return `${diffDays}天前`;
      if (diffDays < 30) return `${Math.floor(diffDays / 7)}周前`;
      if (diffDays < 365) return `${Math.floor(diffDays / 30)}个月前`;
      return `${Math.floor(diffDays / 365)}年前`;
    } catch (error) {
      console.error('时间格式化错误:', error);
      return '未知时间';
    }
  },
  
  getArticleList(showLoading = true) {
    console.log('[DEBUG] 进入getArticleList方法, showLoading:', showLoading);
    const openId = wx.getStorageSync('openId');
    if (!openId) {
      console.log('[DEBUG] getArticleList - 未找到openId，无法获取文档列表');
      this.setData({ documents: [] }); // 如果未登录，清空列表
      return;
    }

    // 只有在需要显示loading时才显示
    if (showLoading) {
      console.log('[DEBUG] getArticleList - 显示loading');
      wx.showLoading({
        title: '加载中...',
      });
    }

    console.log('[DEBUG] getArticleList - 准备调用api.article.getList接口');
    api.article.getList({ openId: openId }, { showLoading: false })
      .then(res => {
        // 只有在showLoading为true时才关闭loading
        if (showLoading) {
          console.log('[DEBUG] getArticleList - 准备关闭loading');
          wx.hideLoading();
          console.log('[DEBUG] getArticleList - loading已关闭');
        }
        console.log('[DEBUG] getArticleList - 成功获取文档列表:', res);
        // 对返回的数据进行格式化，以匹配WXML的渲染需求
        const formattedDocuments = res.map(item => {
          const fileName = item.fileName || '未命名文件';
          // 根据文件类型设置不同的图标
          let iconClass = 'icon-file-unknown';
          if (fileName.endsWith('.pdf')) iconClass = 'icon-pdf';
          if (fileName.endsWith('.doc') || fileName.endsWith('.docx')) iconClass = 'icon-word';

          // 处理头像URL，添加IMG_URL前缀
          const avatarUrl = item.avatarUrl 
            ? IMG_URL + item.avatarUrl 
            : '/assets/images/wxlogo.png'; // 默认头像
            
          // 处理签名模式
          const signModel = item.signModel ? parseInt(item.signModel) : 1;
          const signModelText = signModel === 1 ? '单签' : '多签';
          const signModelClass = signModel === 1 ? 'single' : 'multiple';

          return {
            id: item.id,
            title: fileName,
            // 假设后端返回的createTime是 "YYYY-MM-DD HH:mm:ss" 格式
            date: item.createTime ? item.createTime : '未知日期',
            // 假设后端返回文件类型，如果没有则从文件名判断
            type: item.type || fileName.split('.').pop().toUpperCase(),
            icon: iconClass,
            // 保存原始的fileId，可能用于后续的文件操作
            fileId: item.fileId,
            // 添加签名人数字段
            signCount: item.signCount || 0,
            // 添加签名标志字段
            signFlag: item.signFlag || 0,
            // 添加发起人信息
            creatorNickName: item.nickName || '未知用户',
            creatorAvatarUrl: avatarUrl,
            // 添加签名模式
            signModel: signModel,
            signModelText: signModelText,
            signModelClass: signModelClass
          };
        });

        this.setData({
          documents: formattedDocuments
        });
      })
              .catch(err => {
        // 只有在showLoading为true时才关闭loading
        if (showLoading) {
          console.log('[DEBUG] getArticleList - 错误情况下准备关闭loading');
          wx.hideLoading();
          console.log('[DEBUG] getArticleList - 错误情况下loading已关闭');
        }
        console.error('[DEBUG] getArticleList - 获取文档列表失败', err);
        // 此处无需额外提示，因为request.js已统一处理
      });
  },

  // 返回Promise的版本，用于链式调用
  getArticleListPromise() {
    const listStartTime = Date.now();
    console.log('[DEBUG] 进入getArticleListPromise方法, 时间戳:', listStartTime);
    return new Promise((resolve, reject) => {
      const openId = wx.getStorageSync('openId');
      if (!openId) {
        console.log('[DEBUG] 未找到openId，无法获取文档列表, 时间戳:', Date.now());
        this.setData({ documents: [] }); // 如果未登录，清空列表
        console.log('[DEBUG] 清空列表完成，准备resolve, 时间戳:', Date.now());
        resolve();
        return;
      }

      console.log('[DEBUG] 准备调用api.article.getList接口, 时间戳:', Date.now());
      // 禁用request.js的自动loading管理，我们手动管理
      api.article.getList({ openId: openId }, { showLoading: false })
        .then(res => {
          console.log('[DEBUG] 获取文档列表接口返回成功, 时间戳:', Date.now(), '耗时:', Date.now() - listStartTime + 'ms', res);
          // 对返回的数据进行格式化，以匹配WXML的渲染需求
          const formattedDocuments = res.map(item => {
            const fileName = item.fileName || '未命名文件';
            // 根据文件类型设置不同的图标
            let iconClass = 'icon-file-unknown';
            if (fileName.endsWith('.pdf')) iconClass = 'icon-pdf';
            if (fileName.endsWith('.doc') || fileName.endsWith('.docx')) iconClass = 'icon-word';

            // 处理头像URL，添加IMG_URL前缀
            const avatarUrl = item.avatarUrl 
              ? IMG_URL + item.avatarUrl 
              : '/assets/images/wxlogo.png'; // 默认头像
              
            // 处理签名模式
            const signModel = item.signModel ? parseInt(item.signModel) : 1;
            const signModelText = signModel === 1 ? '单签' : '多签';
            const signModelClass = signModel === 1 ? 'single' : 'multiple';

            return {
              id: item.id,
              title: fileName,
              // 假设后端返回的createTime是 "YYYY-MM-DD HH:mm:ss" 格式
              date: item.createTime ? item.createTime : '未知日期',
              // 假设后端返回文件类型，如果没有则从文件名判断
              type: item.type || fileName.split('.').pop().toUpperCase(),
              icon: iconClass,
              // 保存原始的fileId，可能用于后续的文件操作
              fileId: item.fileId,
              // 添加签名人数字段
              signCount: item.signCount || 0,
              // 添加签名标志字段
              signFlag: item.signFlag || 0,
              // 添加发起人信息
              creatorNickName: item.nickName || '未知用户',
              creatorAvatarUrl: avatarUrl,
              // 添加签名模式
              signModel: signModel,
              signModelText: signModelText,
              signModelClass: signModelClass
            };
          });

          console.log('[DEBUG] 准备调用setData更新文档列表, 时间戳:', Date.now());
          this.setData({
            documents: formattedDocuments
          });
          console.log('[DEBUG] setData完成，准备resolve Promise, 时间戳:', Date.now(), '总耗时:', Date.now() - listStartTime + 'ms');
          resolve(); // 数据设置完成后resolve
        })
        .catch(err => {
          console.error('[DEBUG] 获取文档列表失败, 时间戳:', Date.now(), '耗时:', Date.now() - listStartTime + 'ms', err);
          console.log('[DEBUG] 准备reject Promise, 时间戳:', Date.now());
          reject(err); // 失败时reject
        });
    });
  },
  onReady() {
    // 页面初次渲染完成时执行
  },
 
  // 加载示例文档
  loadSampleDocument(docId, actionType = 'preview') {
    wx.showLoading({
      title: '加载中...',
    });
    
    // 检查登录状态
    const openId = wx.getStorageSync('openId');
    
    // 根据操作类型设置 signType
    let signType = 1; // 默认预览
    if (actionType === 'preview') {
      signType = 1; // 预览文档
    } else if (actionType === 'resign') {
      signType = 2; // 重新签名
    }
    
    // 构建URL参数
    let url = `../pdf-viewer/pdf-viewer?pdfId=${docId}&actionType=${actionType}&signType=${signType}`;
    
    // 如果已登录，必须传递 openId
    if (openId) {
      url += `&openId=${openId}`;
      console.log('[示例文件] 用户已登录，传递 openId:', openId, '操作类型:', actionType, 'signType:', signType);
    } else {
      console.log('[示例文件] 用户未登录，操作类型:', actionType, 'signType:', signType);
    }
    
    wx.navigateTo({ 
      url,
      success: () => {
        wx.hideLoading();
        console.log('[示例文件] 成功跳转到PDF查看器, 操作类型:', actionType);
      },
      fail: (err) => {
        wx.hideLoading();
        console.error('[示例文件] 跳转到PDF查看器失败', err);
        wx.showToast({
          title: '打开文档失败',
          icon: 'none'
        });
      }
    });
  },
})
